package Dominio.Controladores;

import Datos.CtrlDatos;
import Dominio.DiccionarioNoticias;
import Dominio.DiccionarioPalabras;
import Dominio.DiccionarioTemas;
import Dominio.NoEstaNoticiaException;
import Dominio.NoEstaTemaException;
import Dominio.NoticiaClasificada;
import Dominio.PalFrec;
import Dominio.PalabraParaAnadir;
import Dominio.Tema;
import java.util.Vector;
import vistas2.AuxNoticia;
import Vistas.FrecPal;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.StreamCorruptedException;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author sandra
 */
public class CtrlDominio {

    private DiccionarioNoticias dN; //Diccionario de noticias clasificadas
    private DiccionarioPalabras dP; //Diccionario de palabras
    private DiccionarioPalabras dPN; //Diccionario de palabras no funcionales
    private DiccionarioTemas dT; //Diccionario de Temas
    private CtrlDatos CD = new CtrlDatos();
    private static CtrlDominio INSTANCE = null;
    //private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    //private static StringBuffer str = new StringBuffer();
    protected CtrlDominio() {
    }

    private synchronized static void createInstance() {
        if (INSTANCE == null) {
            INSTANCE = new CtrlDominio();
        }
    }

    public static CtrlDominio getInstance() {
        if (INSTANCE == null) {
            createInstance();
        }
        return INSTANCE;
    }

    public Vector<NoticiaClasificada> getNoticias() {
        return dN.getNoticiaClasificadas();
    }

    public void getNoticias(NoticiaClasificada not) {
        dN.addNoticiaClasificada(not);
    }

    public boolean estaNoticia(String not) {
        return dN.estaNoticia(not);
    }

    public NoticiaClasificada getNoticiaClasificada(String not) throws NoEstaNoticiaException {
        return dN.getNoticiaClasificada(not);
    }

    public void incrementarAutomatico(int n) {
        dN.incrementarAutomatico(n);
    }

    public int sizeNoticiasClasificadas() {
        return dN.sizeNoticiasClasificadas();
    }

    public int sizeNoticiasManual() {
        return dN.sizeNoticiasClasificadasManual();
    }

    public void addTema(Tema t) {
        dT.addTema(t);
    }

    public boolean estaTema(String t) {
        return dT.estaTema(t);
    }

    public Tema getTema(String t) throws NoEstaTemaException {
        return dT.getTema(t);
    }

    public Vector<Tema> getTemas() {
        return dT.getTemas();
    }

    public int sizeTemas() {
        return dT.sizeTemas();
    }

    public boolean addPalabra(PalabraParaAnadir p) {
        return dP.addPalabra(p);
    }

    public PalabraParaAnadir consultarPalabra(int id) {
        return (PalabraParaAnadir) dP.consultarPalabra(id);
    }

    public boolean existLetra(char c) {
        return dP.existLetra(c);
    }

    public int existPalabra(String palabra) {
        return dP.existPalabra(palabra);
    }

    public int getTotalPalAvl(char c) {
        return dP.getTotPalAvl(c);
    }

    public int getTotalPalabras() {
        return dP.getTotalPalabras();
    }

    public boolean palabraActivada(String palabra) {
        return dP.palabraActivada(palabra);
    }

    public DiccionarioPalabras getDiccionarioPalabrasNoFuncionales() {
        return dPN;
    }

    public DiccionarioPalabras getDiccioanrioPalabras() {
        return dP;
    }
    
    public String getPathNoticia(String nc) throws NoEstaNoticiaException{
        NoticiaClasificada not=dN.getNoticiaClasificada(nc);
        return not.getPath();
    }

    public void guardarClasificacionAutomatica(Vector<AuxNoticia> auto, Vector<AuxNoticia> manual) {
        for (AuxNoticia a : manual) {
            this.guardarClasificacionManual(a);
        }
        for (AuxNoticia a2 : auto) {
            this.guardarClasificacionAutomatica(a2);
        }
        dN.incrementarAutomatico(auto.size());
    }

    public void guardarClasificacionAutomatica(AuxNoticia aux) {
        NoticiaClasificada nc = new NoticiaClasificada(aux.titulo, aux.cuerpoNot);
        addTemasAuto(aux.temas, nc);
        addNoticiasAuto(aux.palabras, nc);
        dN.addNoticiaClasificada(nc);
    }

    public void guardarClasificacionManual(AuxNoticia aux) {
        try {
            NoticiaClasificada nc = new NoticiaClasificada(aux.titulo, aux.cuerpoNot);
            addTemas(nc, aux.temas, aux.palabras);
            incrementarMarcar(aux.palabras);
            int i = dP.existPalabra(aux.palabras.get(0).pal);
            Tema t = dT.getTema(aux.temas.get(0));
            PalabraParaAnadir pa = (PalabraParaAnadir) dP.consultarPalabra(i);

            System.out.println("se ha añadido? " + pa.estaTema(t));

            dN.addNoticiaClasificada(nc);
        } catch (NoEstaTemaException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void addNoticiasAuto(Vector<FrecPal> palabras, NoticiaClasificada nc) {
        for (FrecPal pal : palabras) {
            int i = dP.existPalabra(pal.pal);
            PalFrec pfrec = new PalFrec();
            if (i != 0) {
                pfrec.p = (PalabraParaAnadir) dP.consultarPalabra(i);
                pfrec.frec = pal.frec;
                nc.addPalabra(pfrec);
            }            
        }

    }

    private void addTemasAuto(Vector<String> temas, NoticiaClasificada nc) {
        for (String t : temas) {
            try {
                nc.addTema(dT.getTema(t));
            } catch (NoEstaTemaException ex) {
            }
        }
    }

    private void incrementarMarcar(Vector<FrecPal> palabras) {
        for (FrecPal fp : palabras) {
            int i = dP.existPalabra(fp.pal);
            PalabraParaAnadir p = (PalabraParaAnadir) dP.consultarPalabra(i);
            p.incApariciones();
            p.marcarPalabra();
        }
    }

    private void addTemas(NoticiaClasificada nc, Vector<String> temas, Vector<FrecPal> palabras) {
        for (String tma : temas) {
            try {
                Tema t = dT.getTema(tma);
                nc.addTema(t);
                t.addNoticiaClasificada(nc);
                addPalabras(nc, t, palabras);
            } catch (NoEstaTemaException ex) {
                Tema t = new Tema(tma);
                nc.addTema(t);
                dT.addTema(t);
                t.addNoticiaClasificada(nc);
                addPalabras(nc, t, palabras);
            }
        }
    }

    private void addPalabras(NoticiaClasificada nc, Tema tema, Vector<FrecPal> palabras) {
        for (FrecPal pal : palabras) {
            int i = dP.existPalabra(pal.pal);
            PalFrec pfrec = new PalFrec();
            if (i == 0) {
                pfrec.p = new PalabraParaAnadir(pal.pal);
                pfrec.frec = pal.frec;
                dP.addPalabra(pfrec.p);
            } else {
                pfrec.p = (PalabraParaAnadir) dP.consultarPalabra(i);
                pfrec.frec = pal.frec;
            }
            nc.addPalabra(pfrec);
            //pfrec.p.marcarPalabra();
            //pfrec.p.incApariciones();
            System.out.println("entra??? " + pfrec.p.estaTema(tema));
            if (!pfrec.p.estaTema(tema)) {
                System.out.println("ha entrado con la palabra; " + pfrec.p.getValor());
                pfrec.p.anadirTema(tema);
                System.out.println("entra??? " + pfrec.p.estaTema(tema));
            }
            if (!tema.esPalabraClave(pal.pal)) {
                tema.addPalabra(pfrec.p);
            }
        }
    }

    public void cargarDiccionarios(String pathNot, String pathPal, String pathTem, String pathPalNoFunc) {
        cargarDiccionarioNoticias(pathNot);
        cargarDiccionarioPalabras(pathPal);
        cargarDiccionarioPalabrasNoFunc(pathPalNoFunc);
        cargarDiccionarioTemas(pathTem);
    }

    private void cargarDiccionarioTemas(String pathTem) {
        try {
            dT = (DiccionarioTemas) CD.getObject(pathTem);
        } catch (StreamCorruptedException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dT = new DiccionarioTemas();
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void cargarDiccionarioNoticias(String pathNot) {
        try {
            dN = (DiccionarioNoticias) CD.getObject(pathNot);
        } catch (StreamCorruptedException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dN = new DiccionarioNoticias();
        } catch (IOException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    private void cargarDiccionarioPalabras(String pathPal) {
        try {
            dP = (DiccionarioPalabras) CD.getObject(pathPal);
        } catch (StreamCorruptedException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dP = new DiccionarioPalabras();
            dP.crearDiccionarioVacio();
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
        // Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void cargarDiccionarioPalabrasNoFunc(String pathPalNoFunc) {
        try {
            dPN = (DiccionarioPalabras) CD.getObject(pathPalNoFunc);
        } catch (StreamCorruptedException ex) {
        //  Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dPN = new DiccionarioPalabras();
            dPN.crearDiccionarioVacio();
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
        //    Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void actualizar(String pathNot, String pathPal, String pathTem, String pathPalNoFunc) {
        guardarDiccionarioNoticias(pathNot);
        guardarDiccionarioTemas(pathTem);
        guardarDiccionarioPalabras(pathPal);
        guardarDiccionarioPalabrasNoFunc(pathPalNoFunc);
    }

    private void guardarDiccionarioNoticias(String pathNot) {
        try {
            CD.setObject(dN, pathNot);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioPalabras(String pathPal) {
        try {
            CD.setObject(dP, pathPal);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioPalabrasNoFunc(String pathPalNoFunc) {
        try {
            CD.setObject(dPN, pathPalNoFunc);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioTemas(String pathTem) {
        try {
            CD.setObject(dT, pathTem);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void crearDiccFile(int idi, String pathP, String pathPN) throws Exception {
        String fs = System.getProperty("file.separator");
        dP = new DiccionarioPalabras();
        dPN = new DiccionarioPalabras();
        dP.crearDiccionarioVacio();
        dPN.crearDiccionarioVacio();
        crearDicc(pathP, 1);
        crearDicc(pathPN, 2);
        switch (idi) {    
            case 1:
                guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DPesp.dicc");
                guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DNFesp.dicc");
                break;
            case 2:
                guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DPcat.dicc");
                guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DNFcat.dicc");
                break;
            case 3:
                guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DPing.dicc");
                guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DNFing.dicc");
                break;
        }
    }

    private void crearDicc(String path, int op) throws Exception {
        String s = CD.getString(path);
        StringTokenizer st = new StringTokenizer(s);
        Integer q = new Integer(Integer.parseInt(st.nextToken()));
        PalabraParaAnadir[] x = new PalabraParaAnadir[q];
        for (int i = 0; i < q; i++) {
            x[i] = new PalabraParaAnadir();
        }
        String pal;
        char[] nacc = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
        char[] acc = {'\u00c0', '\u00c1', '\u00c2', '\u00c4', '\u00c8', '\u00c9', '\u00ca', '\u00cb', '\u00cc', '\u00cd', '\u00ce', '\u00cf', '\u00d2', '\u00d3', '\u00d4', '\u00d6', '\u00d9', '\u00da', '\u00db', '\u00dc', '\u00e0', '\u00e1', '\u00e2', '\u00e4', '\u00e8', '\u00e9', '\u00ea', '\u00eb', '\u00ec', '\u00ed', '\u00ee', '\u00ef', '\u00f2', '\u00f3', '\u00f4', '\u00f6', '\u00f9', '\u00fa', '\u00fb', '\u00fc'};
        for (int i = 0; i < q; i++) {
            pal = st.nextToken();
            for (int j = 0; j < acc.length; j++) {
                pal = pal.replace(acc[j], nacc[j / 4]);
            }
            x[i].setValor(pal);
            if (op == 1) {
                if (dP.existLetra(x[i].getValor().charAt(0))) {
                    if (dP.existPalabra(x[i].getValor()) == 0) {
                        dP.addPalabra(x[i]);
                    }
                }
            } else {
                if (dPN.existLetra(x[i].getValor().charAt(0))) {
                    if (dPN.existPalabra(x[i].getValor()) == 0) {
                        dPN.addPalabra(x[i]);
                    }
                }
            }
        }
    }
}
/*
//El tema se añade al diccionario cuando se de a guardar clasificacion.
public Vector<String> addTema(Vector<String> llt, String tema) throws EstaTemaDiccionarioException {
if (dT.estaTema(tema)) {
throw new EstaTemaDiccionarioException("Ya hay un tema con el nombre: " + tema);
}
//Tema t=new Tema(tema);
llt.add(tema);
return llt;
}
public void guardarClasificacionAutomatica(Vector<AuxNoticia> auto, Vector<AuxNoticia> manual) {
for (AuxNoticia a : manual) {
this.guardarClasificacionManual(a);
}
for (AuxNoticia a2 : auto) {
this.guardarClasificacionAutomatica(a2);
}
dN.incrementarAutomatico(auto.size());
}
public void guardarClasificacionAutomatica(AuxNoticia aux) {
NoticiaClasificada nc = new NoticiaClasificada(aux.titulo, aux.cuerpoNot);
addTemasAuto(aux.temas, nc);
addNoticiasAuto(aux.palabras, nc);
dN.addNoticiaClasificada(nc);
}
public void guardarClasificacionManual(AuxNoticia aux) {
NoticiaClasificada nc = new NoticiaClasificada(aux.titulo, aux.cuerpoNot);
addTemas(nc, aux.temas, aux.palabras);
incrementarMarcar(aux.palabras);
dN.addNoticiaClasificada(nc);
}
public boolean estaDiccionarioNoticias(String titulo) {
return dN.estaNoticia(titulo);
}
public VecTitTex clasificar(String pa) throws NoticiaNoValidaException, NullPointerException, MalformedURLException, IOException {
Vector<String> vec = new Vector<String>(0, 1);
TitTex tt = new TitTex();
Texto tx;
VecTitTex vtt = new VecTitTex();
if (pa.substring(0, 4).compareTo("http") == 0) {
URL page = new URL(pa);
HttpURLConnection conn = (HttpURLConnection) page.openConnection();
conn.connect();
InputStreamReader inr = new InputStreamReader((InputStream) conn.getContent());
BufferedReader buff = new BufferedReader(inr);
String line;
do {
line = buff.readLine();
str.append(line + " ");
} while (line != null);
ParserHttp not = new ParserHttp();
tt = not.sacaTexto(str);
} else {
File fil = new File(pa);
BufferedReader di = new BufferedReader(new FileReader(fil));
String linea;
do {
linea = di.readLine();
if (linea == null) {
break;
} else {
str.append(linea + " ");
}
} while (true);
ParserDisc not = new ParserDisc();
tt = not.sacaTexto(str);
//System.out.println(tx.consultarTexto());
//System.out.println(tx.consultarBiClaves());
//System.out.println(tx.consultarClaves());
}
//try??
str = new StringBuffer("");
tx = new Texto(tt.texto, dPN);//System.out.println("que hay en texto: "+tt.texto);
vtt.vec = new Vector<FrecPal>();
vtt.vec = tx.consultarClaves();
vtt.tit = tt.titulo;
vtt.texto = tt.texto;
return vtt;
}
public Vector<String> listarPalabras() {
int tam = dP.getTotalPalabras();
Vector<String> palabras = new Vector<String>();
for (int i = 1; i < tam + 1; i++) {
palabras.add(dP.consultarPalabra(i).getValor());
}
return palabras;
}
public Vector<String> listarTemaPalabra(String palabra) {
int id = dP.existPalabra(palabra);
PalabraParaAnadir p = (PalabraParaAnadir) dP.consultarPalabra(id);
Vector<String> temas = new Vector<String>();
for (Tema t : p.getTemas()) {
temas.add(t.getNombre());
}
return temas;
}
public Vector<Strouble> sacaTemas(VecTitTex vtt) {
FrecPal fp;
Vector<Strouble> vs = new Vector<Strouble>(0, 1);
Vector<IdFrec> vif = new Vector<IdFrec>(0, 1);
int id;
for (int i = 0; i < vtt.vec.size(); i++) {
fp = (FrecPal) vtt.vec.get(i);
if (dP.existLetra(fp.pal.charAt(0))) {
id = dP.existPalabra(fp.pal);
if (id != 0) {
if (dP.palabraActivada(fp.pal)) {
IdFrec idf = new IdFrec();
idf.id = id;
idf.frec = fp.frec;
vif.add(idf);
}
}
}
}
Vector<Tema> vt = dT.getTemas();
for (Tema t : vt) {
Strouble st = new Strouble();
st.dist = t.getDistancia(vif, dN.sizeNoticiasClasificadasManual(), dP);
System.out.println(st.dist);
st.nom = t.getNombre();
if (st.dist > 0) {
vs.add(st);
}
}
//Strouble st=new Strouble();
//st.nom="Ur fuckin' motha";
//st.dist=0.75;
//vs.add(st);
Collections.sort(vs);
return vs;
}
public boolean existeNoticia(String p) {
return dN.estaNoticia(p);
}
public Vector<Boolean> existenNoticias(Vector<String> pal) {
Vector<Boolean> b = new Vector<Boolean>();
for (String p : pal) {
if (dN.estaNoticia(p)) {
b.add(true);
} else {
b.add(false);
}
}
return b;
}
private void addNoticiasAuto(Vector<FrecPal> palabras, NoticiaClasificada nc) {
for (FrecPal pal : palabras) {
int i = dP.existPalabra(pal.pal);
PalFrec pfrec = new PalFrec();
if (i != 0) {
pfrec.p = (PalabraParaAnadir) dP.consultarPalabra(i);
pfrec.frec = pal.frec;
}
nc.addPalabra(pfrec);
}
}
private void addTemasAuto(Vector<String> temas, NoticiaClasificada nc) {
for (String t : temas) {
if (dT.estaTema(t)) {
try {
nc.addTema(dT.getTema(t));
} catch (NoEstaTemaException ex) {
}
}
}
}
private void crearDicc(String path, int op) throws Exception {
String s = CD.getString(path);
StringTokenizer st = new StringTokenizer(s);
Integer q = new Integer(Integer.parseInt(st.nextToken()));
PalabraParaAnadir[] x = new PalabraParaAnadir[q];
for (int i = 0; i < q; i++) {
x[i] = new PalabraParaAnadir();
}
String pal;
char[] nacc = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
char[] acc = {'\u00c0', '\u00c1', '\u00c2', '\u00c4', '\u00c8', '\u00c9', '\u00ca', '\u00cb', '\u00cc', '\u00cd', '\u00ce', '\u00cf', '\u00d2', '\u00d3', '\u00d4', '\u00d6', '\u00d9', '\u00da', '\u00db', '\u00dc', '\u00e0', '\u00e1', '\u00e2', '\u00e4', '\u00e8', '\u00e9', '\u00ea', '\u00eb', '\u00ec', '\u00ed', '\u00ee', '\u00ef', '\u00f2', '\u00f3', '\u00f4', '\u00f6', '\u00f9', '\u00fa', '\u00fb', '\u00fc'};
for (int i = 0; i < q; i++) {
pal = st.nextToken();
for (int j = 0; j < acc.length; j++) {
pal = pal.replace(acc[j], nacc[j / 4]);
}
x[i].setValor(pal);
if (op == 1) {
if (dP.existLetra(x[i].getValor().charAt(0))) {
if (dP.existPalabra(x[i].getValor()) == 0) {
dP.addPalabra(x[i]);
}
}
} else {
if (dPN.existLetra(x[i].getValor().charAt(0))) {
if (dPN.existPalabra(x[i].getValor()) == 0) {
dPN.addPalabra(x[i]);
}
}
}
}
}
public void crearDiccFile(int idi, String pathP, String pathPN) throws Exception {
String fs = System.getProperty("file.separator");
dP = new DiccionarioPalabras();
dPN = new DiccionarioPalabras();
dP.crearDiccionarioVacio();
dPN.crearDiccionarioVacio();
crearDicc(pathP, 1);
crearDicc(pathPN, 2);
switch (idi) {
case 1:
guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DPesp.dicc");
guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DNFesp.dicc");
break;
case 2:
guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DPcat.dicc");
guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DNFcat.dicc");
break;
case 3:
guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DPing.dicc");
guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "src" + fs + "Diccionarios" + fs + "DNFing.dicc");
break;
}
}
public boolean estaDiccionarioTemas(String tema) {
return dT.estaTema(tema);
}
public Vector<String> listarTemas() {
Vector<String> temas = new Vector<String>(0, 1);
for (Tema t : dT.getTemas()) {
temas.add(t.getNombre());
}
return temas;
}
public Vector<String> listarNoticias() {
Vector<String> noticias = new Vector<String>(0, 1);
for (NoticiaClasificada nc : dN.getNoticiaClasificadas()) {
noticias.add(nc.getTitulo());
}
return noticias;
}
public String listarContNoticia(String noticia) throws NoEstaNoticiaException {
NoticiaClasificada nclas = dN.getNoticiaClasificada(noticia);
return nclas.getCuerpoNoticia();
}
public Vector<String> listarTemaNoticia(String noticia) throws NoEstaNoticiaException {
Vector<String> tema = new Vector<String>(0, 1);
NoticiaClasificada nc = dN.getNoticiaClasificada(noticia);
for (Tema t : nc.getTemas()) {
tema.add(t.getNombre());
}
return tema;
}
public Vector<String> listarPalabrasNoticia(String noticia) throws NoEstaNoticiaException {
Vector<String> palabras = new Vector<String>(0, 1);
NoticiaClasificada nc = dN.getNoticiaClasificada(noticia);
for (PalabraParaAnadir p : nc.getPalabras()) {
palabras.add(p.getValor());
}
return palabras;
}
public Vector<String> listarNoticasTema(String tema) throws NoEstaTemaException {
Vector<String> noticias = new Vector<String>(0, 1);
Tema t = dT.getTema(tema);
for (NoticiaClasificada nc : t.getNoticiasClasificadas()) {
noticias.add(nc.getTitulo());
}
return noticias;
}
public TemaPalabra consultarNoticias(String not) throws NoEstaNoticiaException {
TemaPalabra tp = new TemaPalabra();
tp.palabras = new Vector<String>(0, 1);
tp.temas = new Vector<String>(0, 1);
NoticiaClasificada nc = dN.getNoticiaClasificada(not);
tp.palabras = listarPalabras(nc);
tp.temas = listarTemas(nc);
return tp;
}
public void cargarDiccionarios(String pathNot, String pathPal, String pathTem, String pathPalNoFunc) {
cargarDiccionarioNoticias(pathNot);
cargarDiccionarioPalabras(pathPal);
//        System.out.println(dP.getTotalPalabras());
cargarDiccionarioPalabrasNoFunc(pathPalNoFunc);
//      System.out.println(dPN.getTotalPalabras());
cargarDiccionarioTemas(pathTem);
}
public void actualizar(String pathNot, String pathPal, String pathTem, String pathPalNoFunc) {
guardarDiccionarioNoticias(pathNot);
guardarDiccionarioTemas(pathTem);
guardarDiccionarioPalabras(pathPal);
//necesaria¿??
guardarDiccionarioPalabrasNoFunc(pathPalNoFunc);
}
private void addTemas(NoticiaClasificada nc, Vector<String> temas, Vector<FrecPal> palabras) {
for (String tma : temas) {
try {
Tema t = dT.getTema(tma);
nc.addTema(t);
t.addNoticiaClasificada(nc);
addPalabras(nc, t, palabras);
} catch (NoEstaTemaException ex) {
Tema t = new Tema(tma);
nc.addTema(t);
dT.addTema(t);
t.addNoticiaClasificada(nc);
addPalabras(nc, t, palabras);
}
}
}
public Vector<String> listarPalabrasTema(String t) throws NoEstaTemaException {
Vector<String> p = new Vector<String>();
for (PalabraParaAnadir tx : dT.getTema(t).getPalabras()) {
p.add(tx.valor);
}
return p;
}
public Vector<String> listarTemasPalabra(String p) {
Vector<String> t = new Vector<String>();
int i = dP.existPalabra(p);
PalabraParaAnadir pa = (PalabraParaAnadir) dP.consultarPalabra(i);
for (Tema tx : pa.getTemas()) {
t.add(tx.getNombre());
}
return t;
}
private void addPalabras(NoticiaClasificada nc, Tema tema, Vector<FrecPal> palabras) {
for (FrecPal pal : palabras) {
int i = dP.existPalabra(pal.pal);
PalFrec pfrec = new PalFrec();
if (i == 0) {
pfrec.p = new PalabraParaAnadir(pal.pal);
pfrec.frec = pal.frec;
dP.addPalabra(pfrec.p);
} else {
pfrec.p = (PalabraParaAnadir) dP.consultarPalabra(i);
pfrec.frec = pal.frec;
}
nc.addPalabra(pfrec);
//pfrec.p.marcarPalabra();
//pfrec.p.incApariciones();
if (!pfrec.p.estaTema(tema)) {
pfrec.p.anadirTema(tema);
}
if (!tema.esPalabraClave(pal.pal)) {
tema.addPalabra(pfrec.p);
}
}
}
private void cargarDiccionarioTemas(String pathTem) {
try {
dT = (DiccionarioTemas) CD.getObject(pathTem);
} catch (StreamCorruptedException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
dT = new DiccionarioTemas();
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void cargarDiccionarioNoticias(String pathNot) {
try {
dN = (DiccionarioNoticias) CD.getObject(pathNot);
} catch (StreamCorruptedException ex) {
Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
dN = new DiccionarioNoticias();
} catch (IOException ex) {
Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void cargarDiccionarioPalabras(String pathPal) {
try {
dP = (DiccionarioPalabras) CD.getObject(pathPal);
} catch (StreamCorruptedException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
dP = new DiccionarioPalabras();
dP.crearDiccionarioVacio();
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
// Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void cargarDiccionarioPalabrasNoFunc(String pathPalNoFunc) {
try {
dPN = (DiccionarioPalabras) CD.getObject(pathPalNoFunc);
} catch (StreamCorruptedException ex) {
//  Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
dPN = new DiccionarioPalabras();
dPN.crearDiccionarioVacio();
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
//    Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void guardarDiccionarioNoticias(String pathNot) {
try {
CD.setObject(dN, pathNot);
} catch (SecurityException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void guardarDiccionarioPalabras(String pathPal) {
try {
CD.setObject(dP, pathPal);
} catch (SecurityException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void guardarDiccionarioPalabrasNoFunc(String pathPalNoFunc) {
try {
CD.setObject(dPN, pathPalNoFunc);
} catch (SecurityException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void guardarDiccionarioTemas(String pathTem) {
try {
CD.setObject(dT, pathTem);
} catch (SecurityException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
//Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void incrementarMarcar(Vector<FrecPal> palabras) {
for (FrecPal fp : palabras) {
int i = dP.existPalabra(fp.pal);
PalabraParaAnadir p = (PalabraParaAnadir) dP.consultarPalabra(i);
p.incApariciones();
p.marcarPalabra();
}
}
private Vector<String> listarPalabras(NoticiaClasificada nc) {
Vector<String> palabras = new Vector<String>(0, 1);
for (PalabraParaAnadir pa : nc.getPalabras()) {
palabras.add(pa.getValor());
}
return palabras;
}
private Vector<String> listarTemas(NoticiaClasificada nc) {
Vector<String> temas = new Vector<String>(0, 1);
for (Tema t : nc.getTemas()) {
temas.add(t.getNombre());
}
return temas;
}*/



